package day0610

/**
  * @program: hadoop
  * @description: 隐式转换函数
  * @author: Qiang.Ye
  * @date: 2019-06-13 07:06
  *
  *        注意：谨慎使用隐式函数，隐式转换函数会导致scala的可读性进一步变差
  *        隐式转换函数命名：xxx2xxx
  **/
class Fruit(name:String){
   def getFruitName() : String = name;
}
class  Monkey(f:Fruit){
   def getSay() = println("Monkey like "+f.getFruitName())
}

object ImplicitDemo {

  def main(args: Array[String]): Unit = {
    //定义一个水果：
    /**
      * 问题：可否 f.say
      * 直接写会报错，因为Fruit里面没有say
      * 但是Monkey里面有say函数
      * 如果可以把Fruit转换为Money的话，就可以调用say
      * 所以我们定义隐式函数
      */
    var f : Fruit = new Fruit("Banana")
    f.getSay()

    //隐式参数：
    /**
      *
      * 隐式参数：定义一个implicit修饰的参数
      * scala> def tesstParam(name:String)= println("The value is "+name)
      * tesstParam: (name: String)Unit
      * *
      * scala> def tesstParam(implicit name:String)= println("The value is "+name)
      *  tesstParam: (implicit name: String)Unit
      *  scala> tesstParam
      * *The value is AAA
      * scala> tesstParam("aa")
      * The value is aa
      * scala> implicit val name2:String = "BBBB"
      * ame2: String = BBBB
      *
      * scala> tesstParam  （此处有2个隐式函数，不知道需要调用哪个，故会报错）
      * <console>:19: error: ambiguous implicit values:
      * both value name of type => String
      * and value name2 of type => String
      *  match expected type String
      *
      *解释：
      * 这里的order就是一个隐式函数，使用Ordered类来作为他的值，表示该类可以被排序，即可以被比较
      * 相当于扩充了属性的性能
      * a<b中的< 是Order中的一个函数
      */
    def smaller[T](a:T,b:T)(implicit ordered: T=>Ordered[T]) = if(a<b) a else b
    val  s1 = smaller(100,23) //此处会返回23
    println(s1)

  }

  /**
    * 隐式转换
    * @param f
    * @return
    */
  implicit def  fruit2Mokey(f:Fruit): Monkey ={
    new Monkey(f)
  }
}


